<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>数组常用方法</title>
</head>

<body>
  <!--
    1.push()
      语法：数组.push（数据）
      作用：将数据追加到数组的末尾
      返回值：追加数据后数组 最新长度
    2.pop()
      语法：数组.pop()
      作用：删除数组 最后一个 数据
      返回值：被删除的数据
    3.unshift()
      语法：数组.unshift()
      作用：将数据 添加 到数组的 最前
      返回值：添加数据后数组 最新长度
    4.shift()
      语法：数组.shift()
      作用：删除数组 最前一个 数据
      返回值：被删除的数据
    5.reverse()
      语法：数组.reverse()
      作用：将数组顺序反转
      返回值：反转后的数组
    6.splice()
      语法：数组.splice(开始索引，多少个，要插入的数据)
           开始索引：默认0
           多少个：默认0
           要插入的数据：默认是没有
      作用：删除数组中若干数据，并选择是否插入新的数据
      返回值：以新数组的形式返回被删除的数据
    7.sort()
    语法：数组.sort()
          数组.sort（function(a,b）{return a - b})
          数组.sort（function(a,b）{return b - a})
    作用：将数组进行排序
    返回值：排序好的新数组
    8.join()
    语法：数组.join(连接符)
    作用：将数组用连接符连接成为一个字符串
    返回值：连接好的字符串
    9.concat()
    语法：数组.concat(其他数组)
    作用：将其它数组和数组拼接在一起
    返回值：拼接好的新数组
    10.slice()
    语法：数组.slice(开始索引，结束索引)
         开始索引：默认为0
         结束索引：默认为数组长度
    作用：截取 数组中的某些数据
    返回值：以新数组的形式返回截取出来的数据
    11.indexOf()
    语法：数组.indexOf(数据)
    作用：查找数据在数组中的索引位置
    返回值：有该数据，返回第一次出现的索引位置
           没有该数据，返回-1
    12.forEach()
    语法：数组.forEach(function(item,index,arr){})
    作用：遍历 数组
    返回值：无
    13.map()
    语法：数组.map(function(item,index,arr){})
    作用：映射数组
    返回值：映射后的新数组
    14.filter()
    语法：数组.filter(function(item,index,arr){})
    作用：过滤 数组
    返回值：过滤后的 新数组
    15.every()
    语法：数组.every(function(item,index,arr){})
    作用：判断数组是不是 每一项 都满足条件
    返回值：一个布尔值
    16.some()
     语法：数组.some(function(item,index,arr){})
     作用：判断数组是不是有 某一项 满足条件
     返回值：一个布尔值

     前八种改变原始数组 后八种方法不改变原始数组
    -->

  <script>
    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行push方法
    var res = arr.push('追加的')
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)//返回值是长度5

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行pop方法
    var res = arr.pop()
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res) //返回值是被删除的400

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行unshift方法
    var res = arr.unshift('添加的')
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)//返回值是长度5

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行shift方法
    var res = arr.shift()
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)//返回值是被删除的100

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行reverse方法
    var res = arr.reverse()
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行splice方法
    var res = arr.splice(1, 0, '新来的')
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = [11, 1, 22]
    //输出一次
    console.log(arr)
    //执行sort方法
    //var res = arr.sort()
    var res = arr.sort(function (a, b) {
      console.log(a);
      console.log(b);
      return b - a
    })//从大到小排序
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行join方法
    var res = arr.join('+')
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行concat方法
    var res = arr.concat([500, 600])
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行slice方法
    var res = arr.slice(0, 2)//包前不包后 包含开始索引，不包含结束索引1
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行indexOf方法
    var res = arr.indexOf(200)
    //输出一次数组
    console.log(arr)
    //输出一次返回值
    console.log(res)//结果为1

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行forEach方法
    var res = arr.forEach(function (item, index, arr) {
      //item 就是数组的每一项
      console.log(item)
      //index 就是索引
      console.log(index)
      //arr 就是原始数组
      console.log(arr)
      //输出一个分割线
      console.log('-----------')
    }
    )


    //准备一个原始数组
    var arr = [100, , 300, 400]
    //输出一次
    console.log(arr)
    //执行map方法
    var res = arr.map(function (item, index, arr) {
      //以returm的方式书写映射条件
      return item * 10//给数组的每一项放大了10倍
    }
    )
    //输出一次返回值
    console.log(res)
    console.log(arr)

    //准备一个原始数组
    var arr = [100, , 300, 400, null, undefined]
    //输出一次
    console.log(arr)
    //执行filter方法
    var res = arr.filter(function (item, index, arr) {
      //以return的方式书写过滤条件
      return item !== null && item !== undefined
    })
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行every方法
    var res = arr.every(function (item, index, arr) {
      //以return的方式书写过滤条件
      return item > 150//结果是false 因为不是每一项都大于150
    })
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = [100, 200, 300, 400]
    //输出一次
    console.log(arr)
    //执行some方法
    var res = arr.some(function (item, index, arr) {
      //以return的方式书写过滤条件
      return item > 300
    })
    //输出一次返回值
    console.log(res)



    //准备一个原始数组
    var arr = []
    //执行some方法
    var res = arr.some(function (item, index, arr) {
      //以return的方式书写过滤条件
      return item > 300
    })
    //输出一次返回值
    console.log(res)

    //准备一个原始数组
    var arr = []
    //执行some方法
    var res = arr.every(function (item, index, arr) {
      //以return的方式书写过滤条件
      return item > 300
    })
    //输出一次返回值
    console.log(res)



    var arr = [1, 2, 3]
    var res = arr.join('+')
    console.log(res);
    console.log(eval(res));


    let a = [1, 2, 3, 4, 5]
    // 数组.reduce(累加器,起始值)
    let b = a.reduce((x, y) => {
      console.log(x, y);
      return x * y
    },
    )
    console.log(a);
    console.log(b);

    // let maxarr = [1, '2', true, undefined, null]
    // // 数组.reduce(累加器,起始值)
    // // 累加器是一个函数接收4个参数
    // console.log(
    //   maxarr.reduce((sum, item, index, arr) => {
    //     console.log('sum:', sum);
    //     console.log('item:', item);
    //     console.log('index:', index);
    //     console.log('arr:', arr);
    //     // return的值会被当成下一次循环的sum
    //     return sum + item;
    //   }, 5)
    // );

    // let a1 = [2, 3, 4]
    // b1 = a1.reduceRight((acc, val) => {
    //   console.log(acc, val);
    //   return Math.pow(val, acc)
    // })
    // console.log(b1);
  </script>
</body>

</html>